// /**
//  * Printing helpers that prioritize LODOP.
//  * Only A5 (portrait) and 80 mm thermal paper are supported for now.
//  */

// export interface PrintConfig {
//   /** HTML string or DOM element that needs to be printed */
//   content: string | HTMLElement;
//   /** Optional print window title */
//   title?: string;
//   /** Style configuration */
//   styles?: {
//     /** Paper size, only A5 and A80 are handled */
//     pageSize?: 'A5' | 'A80' | string;
//     /** Orientation, defaults to portrait */
//     orientation?: 'portrait' | 'landscape';
//     /** Page margin */
//     margin?: string;
//     /** Content padding inside the printable area */
//     contentPadding?: string;
//     /** Custom content width */
//     contentWidth?: string;
//     /** Custom content height */
//     contentHeight?: string;
//     /** Extra CSS */
//     customStyles?: string;
//   };
//   onBeforePrint?: () => void;
//   onAfterPrint?: () => void;
//   /** Delay (ms) before removing helper iframe when falling back to browser print */
//   removeDelay?: number;
// }

// export const PAPER_SIZES = {
//   A5: { width: '148mm', height: '210mm', name: 'A5' },
//   A80: { width: '80mm', height: 'auto', name: 'A80' },
// } as const;

// type PaperSizeKey = keyof typeof PAPER_SIZES;
// const DEFAULT_PAGE_SIZE: PaperSizeKey = 'A5';

// const PAGE_STYLE_PRESETS: Record<
//   PaperSizeKey,
//   { margin: string; padding: string }
// > = {
//   A5: { margin: '8mm 2mm 8mm 2mm', padding: '2mm' },
//   A80: { margin: '3mm 0mm 3mm 0mm', padding: '2mm' },
// };

// declare global {
//   interface Window {
//     getCLodop?: () => LodopInstance;
//     CLODOP?: LodopInstance;
//   }
// }

// type LodopInstance = {
//   PRINT_INIT: (title: string) => void;
//   ADD_PRINT_HTM: (
//     top: string | number,
//     left: string | number,
//     width: string | number,
//     height: string | number,
//     html: string
//   ) => void;
//   SET_PRINT_PAGESIZE: (
//     orient: number,
//     width: string | number,
//     height: string | number,
//     pageName?: string
//   ) => void;
//   SET_PRINT_MODE?: (modeName: string, value: any) => void;
//   PREVIEW?: () => boolean;
//   PRINT?: () => boolean;
//   [key: string]: any;
// };

// interface ResolvedStyleOptions {
//   pageSize: PaperSizeKey;
//   orientation: 'portrait' | 'landscape';
//   margin: string;
//   customStyles: string;
//   resolvedPadding: string;
//   resolvedWidth?: string;
//   resolvedHeight?: string;
// }

// interface GeneratedStyleResult {
//   css: string;
//   options: ResolvedStyleOptions;
// }

// const convertSizeToLodopValue = (size?: string | number): number => {
//   if (size === undefined || size === null) return 0;
//   if (typeof size === 'number') return size;

//   const normalized = size.trim().toLowerCase();
//   if (!normalized || normalized === 'auto') return 0;

//   const mmMatch = normalized.match(/^(\d+(?:\.\d+)?)mm$/);
//   if (mmMatch) {
//     return Math.round(parseFloat(mmMatch[1] || '0') * 10);
//   }

//   const cmMatch = normalized.match(/^(\d+(?:\.\d+)?)cm$/);
//   if (cmMatch) {
//     return Math.round(parseFloat(cmMatch[1] || '0') * 100);
//   }

//   const inchMatch = normalized.match(/^(\d+(?:\.\d+)?)in(ch|ches)?$/);
//   if (inchMatch) {
//     return Math.round(parseFloat(inchMatch[1] || '0') * 254);
//   }

//   const pxMatch = normalized.match(/^(\d+(?:\.\d+)?)px$/);
//   if (pxMatch) {
//     const pxValue = parseFloat(pxMatch[1] || '0');
//     return Math.round((pxValue * 254) / 96);
//   }

//   const numericValue = Number(normalized);
//   return Number.isFinite(numericValue) ? numericValue : 0;
// };

// interface MarginValues {
//   top: string;
//   right: string;
//   bottom: string;
//   left: string;
// }

// const parseMarginValues = (margin?: string): MarginValues => {
//   const defaultValue = '0mm';
//   if (!margin) {
//     return {
//       top: defaultValue,
//       right: defaultValue,
//       bottom: defaultValue,
//       left: defaultValue,
//     };
//   }

//   const normalized = margin
//     .split(/\s+/)
//     .map((value) => value.trim())
//     .filter(Boolean);

//   const normalizeValue = (value?: string): string => {
//     if (!value || value.toLowerCase() === 'auto') {
//       return defaultValue;
//     }
//     return value === '0' ? defaultValue : value;
//   };

//   const [top, right, bottom, left] = (() => {
//     switch (normalized.length) {
//       case 1:
//         return [normalized[0], normalized[0], normalized[0], normalized[0]];
//       case 2:
//         return [normalized[0], normalized[1], normalized[0], normalized[1]];
//       case 3:
//         return [normalized[0], normalized[1], normalized[2], normalized[1]];
//       default:
//         return [
//           normalized[0],
//           normalized[1],
//           normalized[2],
//           normalized[3] ?? normalized[1],
//         ];
//     }
//   })();

//   return {
//     top: normalizeValue(top),
//     right: normalizeValue(right),
//     bottom: normalizeValue(bottom),
//     left: normalizeValue(left),
//   };
// };

// const convertToMillimeter = (value?: string | number): number => {
//   const result = convertSizeToLodopValue(value);
//   return result ? result / 10 : 0;
// };

// const getPrimaryLengthValue = (value?: string): string | undefined => {
//   if (!value) return undefined;
//   const normalized = value.trim();
//   if (!normalized) return undefined;
//   const [first] = normalized.split(/\s+/);
//   return first;
// };

// const computeSafeContentWidth = (
//   pageWidth?: string,
//   margin?: string,
//   padding?: string
// ): string | undefined => {
//   if (!pageWidth) return undefined;
//   const pageWidthMm = convertToMillimeter(pageWidth);
//   if (!pageWidthMm) return undefined;

//   const resolvedMargin = parseMarginValues(margin);
//   const leftMm = convertToMillimeter(resolvedMargin.left);
//   const rightMm = convertToMillimeter(resolvedMargin.right);
//   const paddingValue = getPrimaryLengthValue(padding);
//   const paddingMm = paddingValue ? convertToMillimeter(paddingValue) : 0;

//   const safeWidth = pageWidthMm - leftMm - rightMm - paddingMm * 2;
//   if (safeWidth <= 0) return undefined;
//   const normalized = Math.max(10, safeWidth);
//   return `${Math.round(normalized * 10) / 10}mm`;
// };

// const resolveStyleOptions = (config: PrintConfig): ResolvedStyleOptions => {
//   const {
//     pageSize,
//     orientation,
//     margin,
//     contentPadding,
//     contentWidth,
//     contentHeight,
//     customStyles = '',
//   } = config.styles || {};

//   const pageSizeName =
//     typeof pageSize === 'string' ? pageSize.toUpperCase() : undefined;

//   const effectivePageSize: PaperSizeKey =
//     pageSizeName && pageSizeName in PAPER_SIZES
//       ? (pageSizeName as PaperSizeKey)
//       : DEFAULT_PAGE_SIZE;

//   const presetSize = PAPER_SIZES[effectivePageSize];
//   const presetStyles = PAGE_STYLE_PRESETS[effectivePageSize];
//   const resolvedMargin = margin ?? presetStyles.margin;
//   const resolvedPadding = contentPadding ?? presetStyles.padding;

//   const resolvedWidth =
//     contentWidth ??
//     computeSafeContentWidth(
//       presetSize.width,
//       resolvedMargin,
//       resolvedPadding
//     ) ??
//     presetSize.width;

//   const resolvedHeight = contentHeight ?? presetSize.height;

//   return {
//     pageSize: effectivePageSize,
//     orientation: orientation ?? 'portrait',
//     margin: resolvedMargin,
//     customStyles,
//     resolvedPadding,
//     resolvedWidth,
//     resolvedHeight,
//   };
// };

// const generatePrintStyles = (config: PrintConfig): GeneratedStyleResult => {
//   const options = resolveStyleOptions(config);
//   const { resolvedWidth, resolvedHeight, resolvedPadding } = options;

//   const bodyHeightStyles =
//     resolvedHeight && resolvedHeight !== 'auto'
//       ? `min-height: ${resolvedHeight};`
//       : '';

//   const css = `
//     * {
//       margin: 0;
//       padding: 0;
//       box-sizing: border-box;
//     }

//     body {
//       margin: 0;
//       padding: ${resolvedPadding};
//       font-family: 'Microsoft YaHei', sans-serif;
//       -webkit-print-color-adjust: exact;
//       print-color-adjust: exact;
//       ${bodyHeightStyles}
//     }

//     .lodop-print-wrapper {
//       width: ${resolvedWidth ?? '100%'};
//       max-width: ${resolvedWidth ?? '100%'};
//       margin-left: auto;
//       margin-right: auto;
//     }

//     .lodop-print-wrapper *,
//     .lodop-print-wrapper *::before,
//     .lodop-print-wrapper *::after {
//       max-width: 100%;
//       box-sizing: border-box;
//     }

//     .lodop-print-wrapper table {
//       width: 100% !important;
//     }

//     @media print {
//       @page {
//         size: ${options.pageSize} ${options.orientation};
//         margin: ${options.margin};
//       }

//       html,
//       body {
//         margin: 0 !important;
//         padding: 0 !important;
//       }

//       body {
//         margin: 0;
//         padding: ${resolvedPadding} !important;
//       }

//       .lodop-print-wrapper {
//         width: ${resolvedWidth ?? '100%'};
//         max-width: ${resolvedWidth ?? '100%'};
//         margin-left: auto;
//         margin-right: auto;
//       }

//       h1, h2, h3, h4, h5, h6 {
//         page-break-after: avoid;
//         page-break-inside: avoid;
//         break-after: avoid;
//         break-inside: avoid;
//       }

//       table, figure, img {
//         page-break-inside: avoid;
//         break-inside: avoid;
//       }

//       tr {
//         page-break-inside: avoid;
//         break-inside: avoid;
//       }

//       .page-break,
//       .print-page-break {
//         page-break-after: always;
//         break-after: page;
//       }

//       .page-break:last-child,
//       .print-page-break:last-child {
//         page-break-after: auto;
//         break-after: auto;
//       }

//       .no-print {
//         display: none !important;
//       }
//     }

//     ${options.customStyles}
//   `;

//   return { css, options };
// };

// const createPrintableDocument = (
//   title: string,
//   styles: string,
//   contentHtml: string
// ): string => {
//   return `
//     <!DOCTYPE html>
//     <html lang="zh-CN">
//       <head>
//         <meta charset="UTF-8" />
//         <meta name="viewport" content="width=device-width, initial-scale=1.0" />
//         <title>${title}</title>
//         <style>${styles}</style>
//       </head>
//       <body>
//         <div class="lodop-print-wrapper">${contentHtml}</div>
//       </body>
//     </html>
//   `;
// };

// const getLodopInstance = (): LodopInstance | null => {
//   if (typeof window === 'undefined') return null;
//   try {
//     if (typeof window.getCLodop === 'function') {
//       const lodop = window.getCLodop();
//       if (lodop) return lodop;
//     }
//     if (window.CLODOP) {
//       return window.CLODOP;
//     }
//   } catch (error) {
//     console.error('获取 LODOP 实例失败:', error);
//   }
//   return null;
// };

// const printWithLodop = (
//   lodop: LodopInstance,
//   documentHtml: string,
//   config: PrintConfig,
//   options: ResolvedStyleOptions,
//   isPreview: boolean
// ): boolean => {
//   try {
//     const title = config.title || '打印文档';
//     lodop.PRINT_INIT(title);
//     if (typeof lodop.SET_PRINT_MODE === 'function') {
//       lodop.SET_PRINT_MODE('AUTO_CLOSE_PREWINDOW', true);
//       lodop.SET_PRINT_MODE('FULL_WIDTH_FOR_OVERFLOW', true);
//     }

//     const orientationCode = options.orientation === 'landscape' ? 2 : 1;
//     const widthParam = convertSizeToLodopValue(
//       PAPER_SIZES[options.pageSize].width
//     );
//     const heightValue = PAPER_SIZES[options.pageSize].height;
//     const heightParam =
//       heightValue && heightValue !== 'auto'
//         ? convertSizeToLodopValue(heightValue)
//         : 0;

//     const marginValues = parseMarginValues(options.margin);

//     lodop.SET_PRINT_PAGESIZE(
//       orientationCode,
//       widthParam,
//       heightParam,
//       PAPER_SIZES[options.pageSize].name
//     );

//     lodop.ADD_PRINT_HTM(
//       marginValues.top,
//       marginValues.left,
//       `RightMargin:${marginValues.right}`,
//       `BottomMargin:${marginValues.bottom}`,
//       documentHtml
//     );

//     // if (isPreview) {
//     //   if (typeof lodop.PREVIEW === 'function') {
//     //     lodop.PREVIEW();
//     //     return true;
//     //   }
//     //   return false;
//     // }

//     if (typeof lodop.PRINT === 'function') {
//       lodop.PRINT();
//       return true;
//     }
//     return false;
//   } catch (error) {
//     console.error('LODOP 打印失败:', error);
//     return false;
//   }
// };

// const printWithBrowser = (
//   documentHtml: string,
//   config: PrintConfig,
//   resolve: (value: boolean) => void
// ): void => {
//   const iframe = document.createElement('iframe');
//   iframe.style.position = 'fixed';
//   iframe.style.top = '-10000px';
//   iframe.style.left = '-10000px';
//   iframe.style.width = '0';
//   iframe.style.height = '0';
//   iframe.style.border = 'none';

//   document.body.appendChild(iframe);
//   const iframeWindow = iframe.contentWindow;
//   const iframeDoc = iframeWindow?.document;

//   if (!iframeWindow || !iframeDoc) {
//     console.error('无法创建打印 iframe');
//     if (iframe.parentNode) {
//       document.body.removeChild(iframe);
//     }
//     resolve(false);
//     return;
//   }

//   iframeDoc.open();
//   iframeDoc.write(documentHtml);
//   iframeDoc.close();

//   const handlePrint = () => {
//     try {
//       iframeWindow.focus();
//       iframeWindow.print();

//       const removeDelay = config.removeDelay ?? 500;
//       setTimeout(() => {
//         try {
//           if (iframe.parentNode) {
//             document.body.removeChild(iframe);
//           }
//           config.onAfterPrint?.();
//           resolve(true);
//         } catch (error) {
//           console.error('移除 iframe 失败:', error);
//           resolve(true);
//         }
//       }, removeDelay);
//     } catch (error) {
//       console.error('浏览器打印失败:', error);
//       if (iframe.parentNode) {
//         document.body.removeChild(iframe);
//       }
//       resolve(false);
//     }
//   };

//   if (iframeWindow.document.readyState === 'complete') {
//     setTimeout(handlePrint, 100);
//   } else {
//     iframe.onload = handlePrint;
//   }
// };

// const getPrintContent = (config: PrintConfig): string => {
//   if (typeof config.content === 'string') {
//     return config.content;
//   }
//   if (config.content instanceof HTMLElement) {
//     return config.content.innerHTML;
//   }
//   return '';
// };

// const executePrint = async (
//   config: PrintConfig,
//   isPreview: boolean
// ): Promise<boolean> => {
//   if (typeof window === 'undefined') {
//     console.error('打印功能只能在浏览器环境中使用');
//     return false;
//   }

//   return new Promise((resolve) => {
//     try {
//       config.onBeforePrint?.();

//       const contentHtml = getPrintContent(config);
//       const { css, options } = generatePrintStyles(config);
//       const title = config.title || '打印文档';
//       const documentHtml = createPrintableDocument(title, css, contentHtml);

//       const lodop = getLodopInstance();
//       if (lodop) {
//         const lodopResult = printWithLodop(
//           lodop,
//           documentHtml,
//           config,
//           options,
//           isPreview
//         );
//         if (lodopResult) {
//           config.onAfterPrint?.();
//           resolve(true);
//           return;
//         }
//         console.warn('LODOP 打印失败，尝试使用浏览器打印');
//       }

//       printWithBrowser(documentHtml, config, resolve);
//     } catch (error) {
//       console.error('执行打印失败:', error);
//       resolve(false);
//     }
//   });
// };

// export const printPreview = async (config: PrintConfig): Promise<boolean> => {
//   return await executePrint(config, true);
// };

// export const printDirect = async (config: PrintConfig): Promise<boolean> => {
//   return await executePrint(config, false);
// };

// export const printCommon = async (
//   config: PrintConfig,
//   isPreview: boolean = false
// ): Promise<boolean> => {
//   return isPreview ? await printPreview(config) : await printDirect(config);
// };

// export const printElement = async (
//   element: HTMLElement | string,
//   options: Omit<PrintConfig, 'content'> = {}
// ): Promise<boolean> => {
//   let targetElement: HTMLElement | null = null;

//   if (typeof element === 'string') {
//     targetElement = document.querySelector(element);
//     if (!targetElement) {
//       console.error(`未找到元素: ${element}`);
//       return false;
//     }
//   } else {
//     targetElement = element;
//   }

//   return await printCommon({
//     ...options,
//     content: targetElement,
//   });
// };

// export const printHtml = async (
//   html: string,
//   options: Omit<PrintConfig, 'content'> = {}
// ): Promise<boolean> => {
//   return await printCommon({
//     ...options,
//     content: html,
//   });
// };

// /** Batch printing configuration */
// export interface BatchPrintConfig {
//   printConfigs: PrintConfig[];
//   delayBetweenPrints?: number;
//   onProgress?: (current: number, total: number, config: PrintConfig) => void;
//   onComplete?: (successCount: number, failCount: number) => void;
//   continueOnError?: boolean;
// }

// export interface BatchPrintResult {
//   total: number;
//   successCount: number;
//   failCount: number;
//   results: Array<{
//     index: number;
//     success: boolean;
//     config: PrintConfig;
//     error?: any;
//   }>;
// }

// export const printMultiple = async (
//   batchConfig: BatchPrintConfig
// ): Promise<BatchPrintResult> => {
//   const {
//     printConfigs,
//     delayBetweenPrints = 1000,
//     onProgress,
//     onComplete,
//     continueOnError = true,
//   } = batchConfig;

//   const results: BatchPrintResult['results'] = [];
//   let successCount = 0;
//   let failCount = 0;

//   for (let i = 0; i < printConfigs.length; i++) {
//     const currentConfig = printConfigs[i];
//     onProgress?.(i + 1, printConfigs.length, currentConfig!);

//     try {
//       const success = await printDirect(currentConfig!);
//       if (success) {
//         successCount++;
//       } else {
//         failCount++;
//         if (!continueOnError) {
//           results.push({
//             index: i,
//             success: false,
//             config: currentConfig!,
//             error: '打印失败',
//           });
//           break;
//         }
//       }

//       results.push({
//         index: i,
//         success,
//         config: currentConfig!,
//       });
//     } catch (error) {
//       failCount++;
//       results.push({
//         index: i,
//         success: false,
//         config: currentConfig!,
//         error,
//       });
//       if (!continueOnError) {
//         break;
//       }
//     }

//     if (i < printConfigs.length - 1 && delayBetweenPrints > 0) {
//       await new Promise((resolve) => setTimeout(resolve, delayBetweenPrints));
//     }
//   }

//   onComplete?.(successCount, failCount);

//   return {
//     total: printConfigs.length,
//     successCount,
//     failCount,
//     results,
//   };
// };

// export const printHtmlArray = async (
//   htmlArray: string[],
//   commonOptions: Omit<PrintConfig, 'content'> = {},
//   batchOptions: Omit<BatchPrintConfig, 'printConfigs'> = {}
// ): Promise<BatchPrintResult> => {
//   const printConfigs: PrintConfig[] = htmlArray.map((html) => ({
//     ...commonOptions,
//     content: html,
//   }));

//   return await printMultiple({
//     ...batchOptions,
//     printConfigs,
//   });
// };

// export interface MergedPrintConfig {
//   htmlArray: string[];
//   options?: Omit<PrintConfig, 'content'>;
//   pageWrapperClass?: string;
//   autoAddPageBreak?: boolean;
// }

// export const printMergedPages = async (
//   config: MergedPrintConfig
// ): Promise<boolean> => {
//   const {
//     htmlArray,
//     options = {},
//     pageWrapperClass = 'print-page-break',
//     autoAddPageBreak = true,
//   } = config;

//   if (!htmlArray || htmlArray.length === 0) {
//     console.error('HTML 内容数组不能为空');
//     return false;
//   }

//   const mergedHtml = htmlArray
//     .map((html, index) => {
//       const isLast = index === htmlArray.length - 1;
//       const breakClass = autoAddPageBreak && !isLast ? pageWrapperClass : '';
//       return `<div class="${breakClass}">${html}</div>`;
//     })
//     .join('\n');

//   return await printHtml(mergedHtml, options);
// };

// export const printMergedElements = async (
//   elements: (HTMLElement | string)[],
//   config: Omit<MergedPrintConfig, 'htmlArray'> = {}
// ): Promise<boolean> => {
//   const htmlArray: string[] = [];

//   for (const element of elements) {
//     let targetElement: HTMLElement | null = null;

//     if (typeof element === 'string') {
//       targetElement = document.querySelector(element);
//       if (!targetElement) {
//         console.error(`未找到元素: ${element}`);
//         continue;
//       }
//     } else {
//       targetElement = element;
//     }

//     htmlArray.push(targetElement.innerHTML);
//   }

//   if (htmlArray.length === 0) {
//     console.error('未找到任何可以打印的元素');
//     return false;
//   }

//   return await printMergedPages({
//     ...config,
//     htmlArray,
//   });
// };
